#include<iostream>
using namespace std;

//class Date
//{
//public:
//	//Date(int year, int month, int day)
//	//{
//	//	_year = year;
//	//	_month = month;
//	//	_day = day;
//	//}
//
//	//初始化列表：每个对象中成员定义的地方
//	// 必须在初始化列表初始化的：
//	// 引用成员变量、const成员变量、自定义类型成员（该类没有默认构造函数）
//	Date(int year, int month, int day)
//		:_year(year)//声明
//		, _month(month)
//		, _day(day)
//	{}
//
//private:
//	int _year;// 定义
//	int _month;
//	int _day;
//};

//class A
//{
//public:
//	// 单参数构造函数
//	A(int a)
//		:_a(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//
//	//多参数构造函数
//	A(int a1, int a2)
//		:_a1(a1)
//		,_a2(a2)
//	{}
//
//	//拷贝构造
//	A(const A& aa)
//		:_a(aa._a)
//	{
//		cout << "A(const A& aa)" << endl;
//	}
//private:
//	int _a;
//	int _a1;
//	int _a2;
//};

// 静态成员:类外定义，类内声明
//class A
//{
//public:
//	A() { ++_scount; }
//	A(const A& t) { ++_scount; }
//	~A() { --_scount; }
//private:
//	int _a1 = 1;
//	int _a2 = 1;
//public:
//	static int _scount;// 声明
//};
//
////定义
//int A::_scount = 0;

//int main()
//{
//	// 多参数构造函数调用的写法
//	/*A a2(1, 2);
//	A a2 = { 1, 2 };
//	const A& aa3 = { 1, 2 };*/
//
//	A aa1;
//	cout << sizeof(aa1) << endl;
//
//	aa1._scount++;
//	cout << A::_scount << endl;
//
//	return 0;
//}


//// 友元函数
//class Date
//{
//	// 声明ostream/istream类 是 Date类 的友元，就可以访问Date类的私有成员
//	friend ostream& operator<<(ostream& _cout, const Date& d);
//	friend istream& operator>>(istream& _cin, Date& d);
//public:
//	Date(int year = 1980, int month = 1, int day = 1)
//		:_year(year)
//		,_month(month)
//		,_day(day)
//	{}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//ostream& operator<<(ostream& _cout, const Date& d)
//{
//	_cout << d._year << "-" << d._month << "-" << d._day << endl;
//	return _cout;
//}
//
//istream& operator>>(istream& _cin, Date& d)
//{
//	_cin >> d._year;
//	_cin >> d._month;
//	_cin >> d._day;
//	return _cin;
//}
//
//
//int main()
//{
//	Date d;
//	cin >> d;
//	cout << d << endl;
//
//	return 0;
//}


//  C/C++ 的内存管理方式
//int main()
//{
//	// 动态申请一个int类型的空间
//	// 不初始化，与malloc没什么区别
//	//int* p1 = new int;
//	//int* p2 = new int[10];
//
//	// 初始化
//	int* p1 = new int(10);
//	int* p2 = new int[10] {1, 2, 3, 4};
//
//	delete p1;
//	delete[] p2;
//
//	return 0;
//}

//class A
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a = 0)" << endl;
//	}
//
//	A(const A& aa)
//		:_a(aa._a)
//	{
//		cout << "A(const A& aa)" << endl;
//	}
//
//	//赋值
//	A& operator=(const A& aa)
//	{
//		cout << "A& operator=(const A& aa)" << endl;
//		if (this != &aa)
//			_a = aa._a;
//		return *this;
//	}
//
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//
//private:
//	int _a;
//};
//
//int main()
//{
//	// 自定义类型， new才会调用构造初始化，malloc不再适用
//	//A* p1 = (A*)malloc(sizeof(A));
//
//	// 开空间/释放空间， 会调用构造函数和析构
//	//A* p2 = new A;
//	//A* p3 = new A(2);
//
//	//delete p2;
//	//delete p3;
//
//	return 0;
//}

//// 定位new: 在已分配的原始内存空间中调用构造函数初始化一个对象
//class A
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a = 0):" << endl;
//	}
//
//	~A()
//	{
//		cout << "~A():" << endl;
//	}
//
//private:
//	int _a;
//};
//
//int main()
//{
//	A* p1 = (A*)malloc(sizeof(A));
//
//	new(p1)A;
//	p1->~A();
//	free(p1);
//
//	A* p2 = (A*)operator new(sizeof(A));
//	new(p2)A(10);
//	p2->~A();
//	operator delete(p2);
//
//	A* p3 = (A*)operator new[](sizeof(A) * 10);
//	for (int i = 0; i < 10; i++)
//		new(p3 + i)A(i);
//	for (int i = 0; i < 10; i++)
//		(p3 + i)->~A();
//	operator delete[](p3);
//
//	return 0;
//}


// 模板
//template<typename T>
//void Swap(T& left, T& right)
//{
//	T temp = left;
//	left = right;
//	right = temp;
//}
//
//int main()
//{
//	int a = 1, b = 2;
//	Swap(a, b);
//
//	return 0;
//}

// 隐式实例化：让编译器根据实参推演参数的实际类型
//template<typename T>
//void Swap(T& left, T& right)
//{
//	T temp = left;
//	left = right;
//	right = temp;
//}
//int main()
//{
//	int a = 1, b = 2;
//	double c = 1.1, d = 2.2;
//	Swap(a, b);
//	Swap(c, d);
//
//	//Swap(a, (int)c);// 不能通过编译，在模板中，编译器一般不会进行类型转换
//
//	//显示实例化
//	Swap<int>(a, b);
//
//	return 0;
//}

// 类模板
template<class T>
class Vector
{
public:
	Vector(size_t capacity = 10)
		:_pDate(new T[capacity])
		,_size(0)
		,_capaity(capacity)
	{}

	~Vector();

	void PushBack(const T& data);
	void PopBack();
	//....

	size_t Size() { return _size; }

	T& operator[](size_t pos)
	{
		assert(pos < _size);
		return _pDate[pos];
	}

private:
	T* _pDate;
	size_t _size;
	size_t _capacity;
};


// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template<class T>
Vector<T>::~Vector()
{
	if (_pData)
		delete[] _pData;
	_size = _capacity = 0;
}

int main()
{
	Vector<int>st1;
	Vector<double>st2;
	return 0;
}

